package com.shlh.saas.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.shlh.saas.common.Result;
import com.shlh.saas.common.UserContext;
import com.shlh.saas.entity.User;
import com.shlh.saas.entity.UserBalance;
import com.shlh.saas.mapper.UserMapper;
import com.shlh.saas.mapper.UserBalanceMapper;
import com.shlh.saas.model.dto.LoginDTO;
import com.shlh.saas.model.dto.RegisterDTO;
import com.shlh.saas.model.dto.SmsLoginDTO;
import com.shlh.saas.model.vo.LoginVO;
import com.shlh.saas.service.AuthService;
import com.shlh.saas.service.UserBalanceService;
import com.shlh.saas.service.SmsService;
import com.shlh.saas.util.JwtUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceUtils;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import javax.sql.DataSource;

import java.math.BigDecimal;
import java.util.Random;
import java.util.UUID;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.TimeUnit;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;

import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import java.util.Collections;
import java.util.Map;
import java.util.HashMap;

/**
 * 认证服务实现类
 */
@Service
@Slf4j
public class AuthServiceImpl implements AuthService {
    
    // 短信验证码缓存，5分钟过期
    private static final Cache<String, String> SMS_CODE_CACHE = CacheBuilder.newBuilder()
            .expireAfterWrite(5, TimeUnit.MINUTES)
            .build();
            
    @Autowired
    private UserMapper userMapper;

    @Autowired
    private UserBalanceMapper userBalanceMapper;

    @Autowired
    private UserBalanceService userBalanceService;

    @Autowired
    private DataSource dataSource;

    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Autowired
    private SmsService smsService;

    @Autowired
    private JwtUtil jwtUtil;

    @Override
    public boolean verifySmsCode(String phone, String code) {
        log.info("验证短信验证码 - 手机号: {}, 验证码: {}", phone, code);
        
        // 从缓存中获取验证码
        String storedCode = SMS_CODE_CACHE.getIfPresent(phone);
        
        if (storedCode == null) {
            log.info("验证码不存在或已过期 - 手机号: {}", phone);
            return false;
        }
        
        // 验证码比对
        boolean isValid = storedCode.equals(code);
        
        // 如果验证成功，从缓存中删除验证码，防止重复使用
        if (isValid) {
            SMS_CODE_CACHE.invalidate(phone);
            log.info("验证码验证成功，已从缓存中删除 - 手机号: {}", phone);
        } else {
            log.info("验证码验证失败 - 手机号: {}", phone);
        }
        
        return isValid;
    }

    /**
     * 获取存储的验证码（仅用于开发环境）
     *
     * @param phone 手机号
     * @return 验证码，如果不存在则返回null
     */
    public String getStoredVerificationCode(String phone) {
        return SMS_CODE_CACHE.getIfPresent(phone);
    }


    /**
     * 注册
     *
     * @param registerDTO 注册信息
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void register(RegisterDTO registerDTO) {
        log.info("开始处理注册请求: username={}, phone={}", 
                registerDTO.getUsername(), registerDTO.getPhone());
        
        try {
            // 检查用户名是否已存在
            if (userMapper.selectCount(new LambdaQueryWrapper<User>()
                    .eq(User::getUsername, registerDTO.getUsername())) > 0) {
                log.warn("用户名已存在: {}", registerDTO.getUsername());
                throw new RuntimeException("用户名已存在");
            }

            // 检查手机号是否已存在
            if (userMapper.selectCount(new LambdaQueryWrapper<User>()
                    .eq(User::getPhone, registerDTO.getPhone())) > 0) {
                log.warn("手机号已被注册: {}", registerDTO.getPhone());
                throw new RuntimeException("手机号已被注册");
            }
            
            // 验证短信验证码
            String verificationCode = getStoredVerificationCode(registerDTO.getPhone());
            if (verificationCode == null || !verificationCode.equals(registerDTO.getCode())) {
                log.warn("验证码不正确或已过期: phone={}, inputCode={}, storedCode={}", 
                    registerDTO.getPhone(), registerDTO.getCode(), verificationCode);
                throw new RuntimeException("验证码不正确或已过期");
            }
            
            // 验证码正确，从缓存中删除
            SMS_CODE_CACHE.invalidate(registerDTO.getPhone());

            // 创建用户
            User user = new User();
            // 直接使用用户输入的用户名，不添加随机后缀
            user.setUsername(registerDTO.getUsername());
            user.setPhone(registerDTO.getPhone());
            // 存储原始密码，不加密
            user.setPassword(registerDTO.getPassword()); // Storing raw password - highly insecure, for temporary compilation only
            log.debug("密码存储完成，长度: {}", registerDTO.getPassword().length());
                
            user.setIsDeleted(0);
            user.setIsFirstLogin(0); // 修改为0，表示不是首次登录，因为用户已经设置了密码
            // 设置创建和更新时间
            user.setCreatedAt(LocalDateTime.now());
            user.setUpdatedAt(LocalDateTime.now());

            log.info("=================== 注册用户信息 ===================");
            log.info("用户名: {}", user.getUsername());
            log.info("手机号: {}", user.getPhone());

            // 使用MyBatis-Plus插入用户
            try {
                log.info("使用MyBatis-Plus插入用户...");
                int result = userMapper.insert(user);
                log.info("MyBatis-Plus插入结果: {}, 用户ID: {}", result, user.getId());
                
                // 验证用户是否插入成功
                User insertedUser = userMapper.selectById(user.getId());
                if (insertedUser == null) {
                    log.error("用户似乎没有成功插入，尝试使用JDBC方式");
                    insertUserWithJdbc(user);
                } else {
                    log.info("用户插入成功: ID={}", insertedUser.getId());
                    
                    // 用户插入成功后，创建用户余额记录
                    createUserBalance(insertedUser);
                }
            } catch (Exception e) {
                log.error("MyBatis-Plus插入异常: {}", e.getMessage(), e);
                
                // 尝试使用JDBC方式插入
                log.info("尝试使用JDBC方式插入用户...");
                insertUserWithJdbc(user);
                
                // 用户插入后，创建用户余额记录
                User insertedUser = userMapper.selectById(user.getId());
                if (insertedUser != null) {
                    createUserBalance(insertedUser);
                }
            }
                
            log.info("用户注册成功，ID: {}, 用户名: {}, 手机号: {}", 
                    user.getId(), user.getUsername(), user.getPhone());
        } catch (Exception e) {
            // 如果出现任何异常，记录详细日志并抛出
            log.error("注册失败: {}", e.getMessage(), e);
            throw new RuntimeException("注册失败: " + e.getMessage());
        }
    }

    /**
     * 为新注册用户创建余额记录
     * @param user 用户对象
     */
    private void createUserBalance(User user) {
        log.info("开始为用户 {} 创建余额记录", user.getUsername());
        
        try {
            // 创建新的用户余额记录
            UserBalance userBalance = new UserBalance();
            userBalance.setUserId(user.getId()); // 设置用户ID
            userBalance.setPhone(user.getPhone());
            userBalance.setVipLevel(0); // 免费用户
            userBalance.setViewRecordsRemaining(1); // 默认可查看1条记录
            userBalance.setExportQuotaRemaining(0); // 无导出额度
            userBalance.setReverseLookupRemaining(0); // 无反查权限
            userBalance.setEmailSendRemaining(0); // 无邮件额度
            userBalance.setEmailPackageLevel(0); // 无邮件套餐
            userBalance.setCreatedAt(LocalDateTime.now());
            userBalance.setUpdatedAt(LocalDateTime.now());
            
            log.info("尝试插入用户余额记录: userId={}, phone={}", user.getId(), user.getPhone());
            
            // 使用MyBatis-Plus插入
            int result = userBalanceMapper.insert(userBalance);
            if (result > 0) {
                log.info("成功创建用户余额记录，ID: {}", userBalance.getId());
            } else {
                log.warn("创建用户余额记录失败，影响行数: {}", result);
            }
        } catch (Exception e) {
            log.error("创建用户余额记录失败: {}", e.getMessage(), e);
            // 这里只记录错误，不抛出异常，以免影响用户注册流程
        }
    }

    /**
     * 创建默认用户余额记录
     * @param phone 用户手机号
     */
    private void createDefaultUserBalance(String phone) {
        log.info("开始为用户 {} 创建默认余额记录", phone);
        
        try {
            // 检查是否已存在余额记录
            UserBalance existingBalance = userBalanceMapper.selectByPhone(phone);
            if (existingBalance != null) {
                log.info("用户 {} 已有余额记录，ID: {}", phone, existingBalance.getId());
                return;
            }
            
            // 查找用户ID
            User user = userMapper.findByPhone(phone);
            if (user == null) {
                log.error("未找到手机号为 {} 的用户", phone);
                return;
            }
            
            // 创建新的用户余额记录
            UserBalance userBalance = new UserBalance();
            userBalance.setPhone(phone);
            userBalance.setUserId(user.getId()); // 设置用户ID
            userBalance.setVipLevel(0); // 免费用户
            userBalance.setViewRecordsRemaining(1); // 默认可查看1条记录
            userBalance.setExportQuotaRemaining(0); // 无导出额度
            userBalance.setReverseLookupRemaining(0); // 无反查权限
            userBalance.setEmailSendRemaining(0); // 无邮件额度
            userBalance.setEmailPackageLevel(0); // 无邮件套餐
            userBalance.setCreatedAt(LocalDateTime.now());
            userBalance.setUpdatedAt(LocalDateTime.now());
            
            log.info("尝试插入用户余额记录: {}", userBalance);
            
            // 尝试使用MyBatis-Plus插入
            int result = userBalanceMapper.insert(userBalance);
            if (result > 0) {
                log.info("成功创建用户 {} 的余额记录，ID: {}", phone, userBalance.getId());
                return;
            } else {
                log.warn("使用MyBatis-Plus插入余额记录失败，结果: {}", result);
            }
            
            // 如果MyBatis-Plus插入失败，尝试使用JDBC插入
            log.info("尝试使用JDBC直接插入用户余额记录");
            insertUserBalanceWithJdbc(phone);
            
        } catch (Exception e) {
            log.error("创建用户余额记录失败: {}", e.getMessage(), e);
            
            // 尝试再次调用userBalanceService
            try {
                log.info("尝试使用UserBalanceService创建用户余额记录");
                boolean result = userBalanceService.updateUserVip(phone, 0, 0, 0, 1, 0);
                log.info("使用UserBalanceService创建用户余额记录结果: {}", result ? "成功" : "失败");
                
                if (!result) {
                    log.warn("UserBalanceService调用失败，尝试最后一次通过JDBC直接操作");
                    insertUserBalanceWithJdbc(phone);
                }
            } catch (Exception ex) {
                log.error("尝试使用UserBalanceService创建用户余额记录时出错: {}", ex.getMessage(), ex);
                throw new RuntimeException("无法创建用户余额记录: " + ex.getMessage());
            }
        }
    }
    
    /**
     * 使用JDBC方式插入用户余额记录
     * @param phone 用户手机号
     */
    private void insertUserBalanceWithJdbc(String phone) {
        log.info("使用JDBC方式插入用户余额记录: {}", phone);
        
        try {
            // 查找用户ID
            User user = userMapper.findByPhone(phone);
            if (user == null) {
                log.error("未找到手机号为 {} 的用户", phone);
                return;
            }
            
            // 创建UserBalance对象
            UserBalance userBalance = new UserBalance();
            userBalance.setPhone(phone);
            userBalance.setUserId(user.getId()); // 设置用户ID
            userBalance.setVipLevel(0); // 免费用户
            userBalance.setViewRecordsRemaining(1); // 默认可查看1条记录
            userBalance.setExportQuotaRemaining(0); // 无导出额度
            userBalance.setReverseLookupRemaining(0); // 无反查权限
            userBalance.setEmailSendRemaining(0); // 无邮件额度
            userBalance.setEmailPackageLevel(0); // 无邮件套餐
            userBalance.setCreatedAt(LocalDateTime.now());
            userBalance.setUpdatedAt(LocalDateTime.now());
            
            // 使用MyBatis-Plus插入记录
            int result = userBalanceMapper.insert(userBalance);
            log.info("MyBatis-Plus插入用户余额结果: {}", result > 0 ? "成功" : "失败");
            
            if (result <= 0) {
                throw new RuntimeException("MyBatis-Plus插入余额记录失败");
            }
            
            log.info("成功插入用户余额记录, ID: {}", userBalance.getId());
        } catch (Exception e) {
            log.error("插入用户余额记录出错: {}", e.getMessage(), e);
            throw new RuntimeException("插入余额记录失败: " + e.getMessage());
        }
    }

    /**
     * 使用MyBatis-Plus插入用户（备用方案）
     */
    private void insertUserWithJdbc(User user) {
        try {
            log.info("使用MyBatis-Plus插入用户: {}", user.getUsername());
            
            // 如果createdAt和updatedAt未设置，则设置当前时间
            if (user.getCreatedAt() == null) {
                user.setCreatedAt(LocalDateTime.now());
            }
            if (user.getUpdatedAt() == null) {
                user.setUpdatedAt(LocalDateTime.now());
            }
            
            // 使用MyBatis-Plus插入用户
            int result = userMapper.insert(user);
            log.info("MyBatis-Plus插入用户结果: {}", result);
            
            if (result != 1) {
                throw new RuntimeException("MyBatis-Plus插入用户失败，影响行数: " + result);
            }
            
            log.info("MyBatis-Plus插入成功，用户ID: {}", user.getId());
        } catch (Exception e) {
            log.error("MyBatis-Plus插入异常: {}", e.getMessage(), e);
            throw new RuntimeException("MyBatis-Plus插入用户失败: " + e.getMessage(), e);
        }
    }

    /**
     * 密码登录
     *
     * @param loginDTO 登录信息
     * @return 登录结果
     */
    @Override
    public LoginVO login(LoginDTO loginDTO) {
        try {
            log.info("处理密码登录请求，用户名/手机号: {}", loginDTO.getUsername());
            
            // 根据用户名或手机号查询用户 - 修复SQL逻辑
            User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                    .and(wrapper -> wrapper
                        .eq(User::getUsername, loginDTO.getUsername())
                        .or()
                        .eq(User::getPhone, loginDTO.getUsername())
                    )
                    .eq(User::getIsDeleted, 0));

            if (user == null) {
                log.warn("用户不存在: {}", loginDTO.getUsername());
                throw new RuntimeException("用户不存在");
            }
            
            log.info("找到用户: ID={}, 用户名={}, 手机号={}", user.getId(), user.getUsername(), user.getPhone());

            // 验证密码
            String rawPassword = loginDTO.getPassword();
            String storedPassword = user.getPassword();
            
            boolean passwordMatches = rawPassword.equals(storedPassword); // Plain text comparison
            log.info("密码验证结果: {}", passwordMatches ? "成功" : "失败");
            
            if (!passwordMatches) {
                log.warn("密码错误，用户: {}", user.getUsername());
                throw new RuntimeException("密码错误");
            }

            // 生成JWT token
            String token = jwtUtil.generateToken(user.getId());
            log.info("生成token: {}", token);
            
            // 更新用户最后登录时间
            user.setUpdatedAt(LocalDateTime.now());
            userMapper.updateById(user);

            // 返回登录结果
            LoginVO loginVO = LoginVO.builder()
                    .id(user.getId())
                    .username(user.getUsername())
                    .token(token)
                    .isFirstLogin(user.getIsFirstLogin())
                    .build();
            
            log.info("用户登录成功: ID={}, 用户名={}", user.getId(), user.getUsername());
            return loginVO;
        } catch (Exception e) {
            log.error("登录过程中发生异常: {}", e.getMessage(), e);
            throw e; // 重新抛出异常，由控制器处理
        }
    }

    /**
     * 短信验证码登录
     *
     * @param smsLoginDTO 短信登录信息
     * @return 登录结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public LoginVO smsLogin(SmsLoginDTO smsLoginDTO) {
        log.info("开始处理短信登录请求: {}", smsLoginDTO.getMobile());
        
        // 校验验证码
        String mobile = smsLoginDTO.getMobile();
        String inputCode = smsLoginDTO.getCode();
        
        // 从缓存获取验证码
        String cachedCode = SMS_CODE_CACHE.getIfPresent(mobile);
        boolean codeValid = cachedCode != null && cachedCode.equals(inputCode);
        
        if (!codeValid) {
            throw new RuntimeException("验证码错误或已过期");
        }

        // 根据手机号查询用户
        User user = userMapper.selectOne(new LambdaQueryWrapper<User>()
                .eq(User::getPhone, mobile)
                .eq(User::getIsDeleted, 0));

        // 如果用户不存在，则自动注册
        boolean isNewUser = false;
        if (user == null) {
            isNewUser = true;
            log.info("手机号 {} 对应的用户不存在，将创建新用户", mobile);
            
            // 创建新用户对象
            user = new User();
            // 直接使用手机号作为用户名，不添加前缀
            user.setUsername(mobile);
            user.setPhone(mobile);
            // 首次登录不设置密码，标记为需要设置密码
            user.setPassword(""); // 空密码，表示需要用户设置
            // 设置其他默认属性
            user.setIsFirstLogin(1); // 只有新用户才需要设置密码
            // 手动设置创建时间和更新时间
            user.setCreatedAt(LocalDateTime.now());
            user.setUpdatedAt(LocalDateTime.now());
            user.setIsDeleted(0);
            
            log.info("=================== 短信登录：准备插入新用户 ===================");
            log.info("用户名: {}", user.getUsername());
            log.info("手机号: {}", user.getPhone());
            log.info("密码: 未设置，等待用户首次设置");
            log.info("注册时间: {}", user.getCreatedAt());
            
            // 插入用户
            try {
                log.info("短信登录：尝试插入新用户");
                int rows = userMapper.insert(user);
                log.info("短信登录：插入新用户结果: {}, 用户ID: {}", rows, user.getId());
                
                if (rows <= 0) {
                    log.error("短信登录：插入新用户失败");
                    throw new RuntimeException("创建用户失败");
                }
                
                // 为新用户创建余额记录
                createUserBalance(user);
            } catch (Exception e) {
                log.error("短信登录：插入新用户异常: {}", e.getMessage(), e);
                throw new RuntimeException("创建用户异常: " + e.getMessage());
            }
        }
        
        // 使用用户ID生成token
        String token = jwtUtil.generateToken(user.getId());
        
        // 是否需要设置密码
        boolean needSetPassword = isNewUser || 
            (user.getIsFirstLogin() != null && user.getIsFirstLogin() == 1) ||
            (user.getPassword() == null || user.getPassword().isEmpty());
        
        if (needSetPassword) {
            log.info("用户需要设置密码: userId={}, isNewUser={}, isFirstLogin={}", 
                     user.getId(), isNewUser, user.getIsFirstLogin());
        } else {
            log.info("用户无需设置密码: userId={}", user.getId());
        }
        
        // 更新用户最后登录时间
        user.setUpdatedAt(LocalDateTime.now());
        userMapper.updateUserById(user);

        // 确保用户有余额记录（如果是已存在用户，检查并创建余额记录）
        if (!isNewUser) {
            try {
                UserBalance userBalance = userBalanceMapper.selectByUserId(user.getId());
                if (userBalance == null) {
                    log.info("短信登录：已存在用户{}无余额记录，开始创建", mobile);
                    createUserBalance(user);
                    log.info("短信登录：成功为已存在用户{}创建余额记录", mobile);
                } else {
                    log.info("短信登录：用户{}已有余额记录", mobile);
                }
            } catch (Exception e) {
                log.error("短信登录：为用户{}检查/创建余额记录时发生异常: {}", mobile, e.getMessage(), e);
                // 不影响登录流程，继续返回登录结果
            }
        }

        // 返回登录结果
        return LoginVO.builder()
                .id(user.getId())
                .username(user.getUsername())
                .token(token)
                .isFirstLogin(needSetPassword ? 1 : 0) // 根据是否需要设置密码来决定
                .build();
    }

    /**
     * 发送短信验证码
     *
     * @param mobile 手机号
     * @return 验证码（仅开发环境返回）
     */
    @Override
    public String sendSmsCode(String mobile) {
        try {
            // 生成6位随机验证码
            String code = String.format("%06d", new Random().nextInt(1000000));
            
            // 将验证码保存到缓存中，有效期5分钟
            SMS_CODE_CACHE.put(mobile, code);
            log.info("验证码已保存到缓存，手机号: {}, 验证码: {}", mobile, code);
            
            // 尝试使用SmsService发送验证码
            try {
                if (smsService != null) {
                    boolean success = smsService.sendVerificationCode(mobile, code);
                    if (!success) {
                        log.warn("SmsService发送验证码失败，但验证码已保存到缓存");
                    } else {
                        log.info("SmsService成功发送验证码");
                    }
                } else {
                    log.warn("SmsService未注入，无法发送实际短信，但验证码已保存到缓存");
                }
            } catch (Exception e) {
                log.error("调用SmsService发送验证码异常", e);
            }
            
            log.info("发送验证码到手机号: {}, 验证码: {}", mobile, code);
            
            // 在开发环境中返回验证码，方便测试
            return code;
        } catch (Exception e) {
            log.error("生成或发送验证码异常", e);
            throw new RuntimeException("发送验证码失败，请稍后重试");
        }
    }

    /**
     * 更新用户密码
     * @param userId 用户ID
     * @param currentPassword 当前密码
     * @param newPassword 新密码
     * @return 更新是否成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePassword(Long userId, String currentPassword, String newPassword) {
        log.info("更新用户密码: userId={}, currentPassword长度={}, newPassword长度={}", 
            userId, 
            currentPassword != null ? currentPassword.length() : 0,
            newPassword != null ? newPassword.length() : 0);
        
        if (userId == null || currentPassword == null || newPassword == null) {
            return false;
        }
        if (newPassword.length() < 6) {
            throw new RuntimeException("新密码长度不能少于6位");
        }

        User user = userMapper.selectById(userId);
        if (user == null) {
            throw new RuntimeException("用户不存在");
        }

        boolean currentPasswordMatches = currentPassword.equals(user.getPassword()); // Plain text comparison
        if (!currentPasswordMatches) {
            throw new RuntimeException("当前密码不正确");
        }

        user.setPassword(newPassword); // Storing raw password
        user.setUpdatedAt(LocalDateTime.now());
        return userMapper.updateById(user) > 0;
    }

    /**
     * 简化版更新用户密码（不验证当前密码）
     * @param userId 用户ID
     * @param newPassword 新密码
     * @return 更新是否成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updatePasswordSimple(Long userId, String newPassword) {
        log.info("简化版更新用户密码: userId={}, newPassword长度={}", 
            userId, newPassword != null ? newPassword.length() : 0);
        
        // 参数验证
        if (userId == null || newPassword == null) {
            log.warn("更新密码参数无效: userId={}", userId);
            return false;
        }
        
        // 检查密码长度
        if (newPassword.length() < 6) {
            log.warn("新密码长度不符合要求({}): userId={}", newPassword.length(), userId);
            throw new RuntimeException("新密码长度不能少于6位");
        }
        
        try {
            // 查询用户
            User user = userMapper.selectById(userId);
            if (user == null) {
                log.warn("用户不存在: userId={}", userId);
                return false;
            }
            
            log.info("找到用户: userId={}, username={}", user.getId(), user.getUsername());
            
            // 直接更新密码，不验证当前密码
            user.setPassword(newPassword);
            user.setUpdatedAt(LocalDateTime.now());
            
            // 保存用户
            int result = userMapper.updateUserById(user);
            if (result != 1) {
                log.error("密码更新失败，数据库返回: {}", result);
                return false;
            }
            
            log.info("密码更新成功: userId={}", userId);
            
            // 尝试在foreigntrade库中也更新密码（如果有多个系统共用用户）
            try {
                log.info("尝试在foreigntrade库中同步更新密码...");
                updatePasswordInForeigntrade(userId, newPassword);
            } catch (Exception e) {
                log.warn("在foreigntrade库中更新密码失败，但不影响主要功能: {}", e.getMessage());
            }
            
            return true;
        } catch (Exception e) {
            log.error("更新密码过程中发生异常: {}", e.getMessage(), e);
            throw new RuntimeException("更新密码失败: " + e.getMessage());
        }
    }

    /**
     * 在foreigntrade库中同步更新密码
     */
    private void updatePasswordInForeigntrade(Long userId, String newPassword) {
        log.info("开始在foreigntrade库中同步更新密码: userId={}", userId);
        try {
            if (userId == null || newPassword == null || newPassword.isEmpty()) {
                log.warn("无效的参数: userId={}, newPassword={}", userId, newPassword);
                return;
            }

            // 使用JdbcTemplate更新外部系统数据库（这是跨数据库操作，所以保留jdbcTemplate）
            String sql = "UPDATE ft_user SET password = :password, update_time = NOW() WHERE id = :userId";
            Map<String, Object> params = new HashMap<>();
            params.put("password", newPassword);
            params.put("userId", userId);
            
            int updatedRows = new NamedParameterJdbcTemplate(jdbcTemplate.getDataSource())
                    .update(sql, params);
            
            log.info("foreigntrade库密码更新结果: userId={}, 更新行数={}", userId, updatedRows);

            if (updatedRows > 0) {
                log.info("foreigntrade库密码更新成功");
                
                // 验证更新结果
                String verifySql = "SELECT password FROM ft_user WHERE id = :userId";
                try {
                    String updatedPassword = new NamedParameterJdbcTemplate(jdbcTemplate.getDataSource())
                            .queryForObject(verifySql, Collections.singletonMap("userId", userId), String.class);
                    boolean passwordMatches = newPassword.equals(updatedPassword);
                    log.info("foreigntrade库密码更新验证: {}", passwordMatches ? "匹配成功" : "匹配失败");
                } catch (Exception e) {
                    log.warn("foreigntrade库密码更新验证失败: {}", e.getMessage());
                }
            } else {
                log.warn("foreigntrade库中未找到用户ID: {}", userId);
            }
        } catch (Exception e) {
            log.error("foreigntrade库密码更新失败: {}", e.getMessage(), e);
            // 不抛出异常，因为这是辅助功能，失败不应影响主要流程
        }
    }

    /**
     * 直接重置用户密码（不验证当前密码）
     * @param password 新密码
     * @param username 用户名（可选）
     * @param phone 手机号（可选）
     * @return 更新是否成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean resetPassword(String password, String username, String phone) {
        log.info("直接重置用户密码: password长度={}, username={}, phone={}", 
            password != null ? password.length() : 0, username, phone);
        
        // 参数验证
        if (password == null || password.length() < 6) {
            log.warn("密码长度不符合要求: {}", password != null ? password.length() : 0);
            throw new RuntimeException("密码长度不能少于6位");
        }
        
        // 构建查询条件
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        boolean hasCondition = false;
        
        if (username != null && !username.isEmpty()) {
            queryWrapper.eq(User::getUsername, username);
            hasCondition = true;
        }
        
        if (phone != null && !phone.isEmpty()) {
            if (hasCondition) {
                queryWrapper.or();
            }
            queryWrapper.eq(User::getPhone, phone);
            hasCondition = true;
        }
        
        if (!hasCondition) {
            // 如果没有提供任何查询条件，查询所有非删除用户
            queryWrapper.eq(User::getIsDeleted, 0);
            log.info("未提供任何查询条件，将查询所有未删除用户进行密码重置");
        }
        
        // 查询符合条件的用户列表
        List<User> users = userMapper.selectList(queryWrapper);
        
        if (users == null || users.isEmpty()) {
            log.warn("未找到符合条件的用户: username={}, phone={}", username, phone);
            return false;
        }
        
        log.info("找到{}个用户需要重置密码", users.size());
        
        // 生成新密码哈希
        String encodedPassword = password;
        log.info("生成的密码哈希: {}...", encodedPassword.substring(0, Math.min(10, encodedPassword.length())));
        
        int successCount = 0;
        
        // 更新每个用户的密码
        for (User user : users) {
            log.info("开始更新用户密码: userId={}, username={}", user.getId(), user.getUsername());
            
            user.setPassword(encodedPassword);
            user.setUpdatedAt(LocalDateTime.now());
            
            // 如果之前是首次登录状态，也更新为非首次登录
            if (user.getIsFirstLogin() != null && user.getIsFirstLogin() == 1) {
                user.setIsFirstLogin(0);
            }
            
            int result = userMapper.updateUserById(user);
            
            if (result == 1) {
                log.info("用户密码重置成功: userId={}", user.getId());
                successCount++;
            } else {
                log.warn("用户密码重置失败: userId={}", user.getId());
            }
        }
        
        log.info("共有{}个用户密码重置成功，{}个失败", successCount, users.size() - successCount);
        
        return successCount > 0;
    }

    /**
     * 退出登录
     */
    @Override
    public void logout() {
        // 从ThreadLocal中获取用户ID
        Long userId = UserContext.getUserId();
        if (userId != null) {
            log.info("用户登出: {}", userId);
        }
        // 清理ThreadLocal
        UserContext.clear();
    }

    @Override
    public String refreshToken() {
        try {
            // 从UserContext获取用户ID
            Long userId = UserContext.getUserId();
            
            if (userId == null) {
                log.warn("刷新Token失败: 未登录");
                return null;
            }
            
            // 生成新的Token
            String newToken = jwtUtil.generateToken(userId);
            log.info("Token刷新成功: userId={}", userId);
            
            return newToken;
        } catch (Exception e) {
            log.error("刷新Token时发生异常", e);
            return null;
        }
    }
    @Override
    public void setPassword(String password) {
        log.info("设置密码请求");
        
        try {
            // 验证参数
            if (password == null || password.isEmpty()) {
                log.warn("密码不能为空");
                throw new RuntimeException("密码不能为空");
            }
            
            // 验证密码格式
            if (password.length() < 6) {
                log.warn("密码长度不符合要求: {}", password.length());
                throw new RuntimeException("密码长度不能少于6位");
            }
            
            // 获取当前用户ID
            Long userId = UserContext.getUserId();
            
            if (userId == null) {
                log.warn("无法获取当前用户信息");
                throw new RuntimeException("无法获取当前用户信息，请重新登录");
            }
            
            // 更新密码
            boolean result = updatePasswordSimple(userId, password);
            if (!result) {
                log.error("设置密码失败: userId={}", userId);
                throw new RuntimeException("设置密码失败，请稍后重试");
            }
            
            log.info("设置密码成功: userId={}", userId);
        } catch (Exception e) {
            log.error("设置密码异常: {}", e.getMessage(), e);
            throw new RuntimeException("设置密码失败: " + e.getMessage());
        }
    }
} 